home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / progtool / c / dev_lib1 / src / port.s < prev    next >
Text File  |  1995-11-25  |  11KB  |  446 lines
  1. *
  2. * assembler routines for using the ports
  3. * author     : Jan Kriesten
  4. * last change: 17.03.1994
  5. *
  6. * tabsize    : 4
  7. *
  8.  
  9.     .INCLUDE "port.sh"
  10.  
  11. *** Hardware-Adressen:
  12. mfp1        EQU        $00fffa01
  13. mfp2        EQU        $00fffa81
  14. sccctl_a    EQU        $ffff8c81
  15. sccdat_a    EQU        $ffff8c83
  16. sccctl_b    EQU        $ffff8c85
  17. sccdat_b    EQU        $ffff8c87
  18.  
  19. *** Bco* - Routinen:
  20. bcon_m1        EQU        $0522.w
  21. bcon_midi    EQU        $052A.w
  22.  
  23.  
  24.         .TEXT
  25.         
  26. ;-------
  27. ; DTR-OFF-Routinen:
  28.  
  29. low_dtr:
  30.         xdef        low_dtr
  31.         
  32.         add.w        d0, d0
  33.         add.w        d0, d0
  34.         
  35.         movea.l        .jmp(pc, d0.w), a1
  36.         jmp            (a1)
  37.  
  38. .jmp:
  39.         dc.l        .dtr_off1, .dtr_off2, .dtr_off3, .dtr_off4
  40.         
  41. .dtr_off1:
  42. ;        move.w        #$10, -(sp)            ; DTR-Bit oderieren
  43. ;        move.w        #$1e, -(sp)            ; Opcode für Ongibit (XBIOS 30)
  44.         move.l        #$001e0010, -(sp)    ;
  45.         trap        #14                    ; XBIOS-Trap
  46.         addq.l        #4, sp                ; Stack restaurieren
  47.         rts
  48.         
  49. .dtr_off2:
  50.         move.l        20(a0), dev            ; Adresse der Iorec-Struktur nach
  51.                                         ; dev
  52.         pea            .low_it2(pc)        ; Im Supervisormodus ausführen
  53.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38)
  54.         trap        #14                    ; XBIOS-Trap
  55.         addq.l        #6, sp                ; Stack restaurieren
  56.         rts
  57.  
  58. .low_it2:
  59.         move.w        sr, d1                ; Status-Register in d1 retten
  60.         ori.w        #$700, sr            ; Interrupts sperren
  61.         
  62.         movea.l        dev(pc), a0            ; Iorec Struktur holen
  63.         move.b        $1d(a0), d0            ; WR5 Schatten nach d0
  64.         andi.b        #$7f, d0            ; DTR aus
  65.         move.b        d0, $1d(a0)            ; WR5 Schatten zurückschreiben
  66.         
  67.         lea            sccctl_b, a0        ; Adresse des SCC-Control-Registers
  68.         move.b        #$05, (a0)            ; Write-Register 5 auswählen
  69.         move.b        d0, (a0)            ; und DTR-Bit löschen (==> DTR low)
  70.         
  71.         move.w        d1, sr                ; Interrupts wieder freigeben
  72.  
  73. .dtr_off3:
  74.         rts
  75.         
  76. .dtr_off4:
  77.         move.l        20(a0), dev            ; Adresse der Iorec-Struktur nach
  78.                                         ; dev
  79.         pea            .low_it4(pc)        ; Im Supervisormodus ausführen
  80.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38)
  81.         trap        #14                    ; XBIOS-Trap
  82.         addq.l        #6, sp                ; Stack restaurieren
  83.         rts
  84.  
  85. .low_it4:
  86.         move.w        sr, d1                ; Status-Register in d1 retten
  87.         ori.w        #$700, sr            ; Interrupts sperren
  88.         
  89.         movea.l        dev(pc), a0            ; Iorec Struktur holen
  90.         move.b        $1d(a0), d0            ; WR5 Schatten nach d0
  91.         andi.b        #$7f, d0            ; DTR aus
  92.         move.b        d0, $1d(a0)            ; WR5 Schatten zurückschreiben
  93.         
  94.         lea            sccctl_a, a0        ; Adresse des SCC-Control-Registers
  95.         move.b        #$05, (a0)            ; Write-Register 5 auswählen
  96.         move.b        d0, (a0)            ; und DTR-Bit löschenn (==> DTR low)
  97.         
  98.         move.w        d1, sr                ; Interrupts wieder freigeben
  99.         rts
  100.  
  101. ;-------
  102. ; DTR-ON-Routinen:
  103.  
  104. high_dtr:
  105.         xdef        high_dtr
  106.         
  107.         add.w        d0, d0
  108.         add.w        d0, d0
  109.         
  110.         movea.l        .jmp(pc, d0.w), a1
  111.         jmp            (a1)
  112.  
  113. .jmp:
  114.         dc.l        .dtr_on1, .dtr_on2, .dtr_on3, .dtr_on4
  115.  
  116. .dtr_on1:
  117. ;        move.w        #$ffe7, -(sp)        ; DTR- und RTS-Bit undieren
  118. ;        move.w        #$1d, -(sp)            ; Opcode für Offgibit (XBIOS 29)
  119.         move.l        #$001dffe7, -(sp)    ;
  120.         trap        #14                    ; XBIOS-Trap
  121.         addq.l        #4, sp                ; Stack restaurieren
  122.         rts
  123.         
  124. .dtr_on2:
  125.         move.l        20(a0), dev            ; Adresse der Iorec-Struktur nach
  126.                                         ; dev
  127.         pea            .high_it2(pc)        ; Im Supervisormodus ausführen
  128.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38)
  129.         trap        #14                    ; XBIOS-Trap
  130.         addq.l        #6, sp                ; Stack restaurieren
  131.         rts
  132.  
  133. .high_it2:
  134.         move.w        sr, d1                ; Status-Register in d1 retten
  135.         ori.w        #$700, sr            ; Interrupts sperren
  136.         
  137.         movea.l        dev(pc), a0            ; Iorec Struktur holen
  138.         move.b        $1d(a0), d0            ; WR5 Schatten nach d0
  139.         ori.b        #$82, d0            ; DTR und RTS an
  140.         move.b        d0, $1d(a0)            ; WR5 Schatten zurückschreiben
  141.         
  142.         lea            sccctl_b, a0        ; Adresse des SCC-Control-Registers
  143.         move.b        #$05, (a0)            ; Write-Register 5 auswählen
  144.         move.b        d0, (a0)            ; und schreiben
  145.         
  146.         move.w        d1, sr                ; Interrupts wieder freigeben
  147.         
  148. .dtr_on3:
  149.         rts
  150.         
  151. .dtr_on4:
  152.         move.l        20(a0), dev            ; Adresse der Iorec-Struktur nach
  153.                                         ; dev
  154.         pea            .high_it4(pc)        ; Im Supervisormodus ausführen
  155.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38)
  156.         trap        #14                    ; XBIOS-Trap
  157.         addq.l        #6, sp                ; Stack restaurieren
  158.         rts
  159.  
  160. .high_it4:
  161.         move.w        sr, d1                ; Status-Register in d1 retten
  162.         ori.w        #$700, sr            ; Interrupts sperren
  163.         
  164.         movea.l        dev(pc), a0            ; Iorec Struktur holen
  165.         move.b        $1d(a0), d0            ; WR5 Schatten nach d0
  166.         ori.b        #$82, d0            ; DTR und RTS an
  167.         move.b        d0, $1d(a0)            ; WR5 Schatten zurückschreiben
  168.         
  169.         lea            sccctl_a, a0        ; Adresse des SCC-Control-Registers
  170.         move.b        #$05, (a0)            ; Write-Register 5 auswählen
  171.         move.b        d0, (a0)            ; und schreiben
  172.         
  173.         move.w        d1, sr                ; Interrupts wieder freigeben
  174.         rts
  175.  
  176. ;-------
  177. ; DCD-Routinen:
  178. is_dcd:
  179.         xdef        is_dcd
  180.         
  181.         add.w        d0, d0
  182.         add.w        d0, d0
  183.         move.l        dcd_funcs(pc, d0.w), -(sp)
  184.         
  185.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38)
  186.         trap        #14                    ; XBIOS-Trap
  187.         addq.l        #6, sp                ; Stack restaurieren
  188.  
  189.         rts
  190.  
  191. dcd_funcs:
  192.         dc.l        .dcd1, .dcd2, .dcd3, .dcd4
  193.  
  194. .dcd1:
  195.         move.b        mfp1, d0            ; dcd holen: ~dcd & 2
  196.         not.b        d0
  197.         andi.w        #2, d0
  198.         rts
  199.  
  200. .dcd2:
  201.         move.b        sccctl_b, d0        ; dcd holen: dcd & 8
  202.         andi.w        #8,d0
  203.         rts
  204.  
  205. .dcd3:
  206.         moveq        #1, d0                ; immer Carrier annehmen!
  207.         rts
  208.         
  209. .dcd4:
  210.         move.b        sccctl_a, d0        ; dcd holen: dcd & 8
  211.         andi.w        #8,d0
  212.         rts
  213.  
  214. ;-------
  215. ; SetMapM1
  216. ; ->    a0: Adresse für Zeiger auf MAPTAB-Struktur
  217. ; <-    nichts
  218. ;
  219. ; Die Funktion setzt die Adressen der I/O-Betriebssystemroutinen
  220. ; für Modem 1 in die lokale Tabelle.
  221. ;
  222. ; Achtung: Nur aufrufen, wenn es _kein_ Bconmap() gibt!!!
  223. ;
  224. SetMapM1:
  225.         xdef        SetMapM1            ; Funktion exportieren
  226.         
  227.         move.l        #.map_m1, (a0)        ; Zeiger einsetzen
  228.         
  229.         pea            .set_m1(pc)            ; Adresse der Funktion auf den Stack
  230.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38)
  231.         trap        #14                    ; XBIOS-Trap
  232.         addq.l        #6, sp                ; Stack restaurieren
  233.         
  234.         clr.w        -(sp)                ; dev: RS232
  235.         move.w        #$E, -(sp)            ; Opcode für Iorec (XBIOS 14)
  236.         trap        #14                    ; XBIOS-Trap
  237.         addq.l        #4, sp                ;
  238.         
  239.         lea            .map_m1(pc), a1        ;
  240.         move.l        d0, iorec(a1)        ;
  241.         
  242.         rts
  243.  
  244. .set_m1:
  245.         lea            .map_m1(pc), a0        ;
  246.         lea            bcon_m1, a1            ;
  247.         move.l        (a1), (a0)+            ;
  248.         move.l        $20(a1), (a0)+        ;
  249.         move.l        $40(a1), (a0)+        ;
  250.         move.l        $60(a1), (a0)        ;
  251.         rts
  252.  
  253. .map_m1:    dcb.b    MAPTAB, 0
  254.  
  255. ;-------
  256. ; SetMapMidi
  257. ; ->    a0: Adresse für Zeiger auf MAPTAB-Struktur
  258. ; <-    nichts
  259. ;
  260. ; Die Funktion setzt die Adressen der I/O-Betriebssystemroutinen
  261. ; für die Midi-Schnittstelle in die lokale Tabelle.
  262. ;
  263. SetMapMidi:
  264.         xdef        SetMapMidi            ; Funktion exportieren
  265.         
  266.         move.l        #.map_midi, (a0)    ; Zeiger einsetzen
  267.         
  268.         pea            .set_midi(pc)        ; Adresse der Funktion auf den Stack
  269.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38)
  270.         trap        #14                    ; XBIOS-Trap
  271.         addq.l        #6, sp                ; Stack restaurieren
  272.         
  273.         move.w        #2, -(sp)            ; dev: MIDI
  274.         move.w        #$E, -(sp)            ; Opcode für Iorec (XBIOS 14)
  275.         trap        #14                    ; XBIOS-Trap
  276.         addq.l        #4, sp                ;
  277.         
  278.         lea            .map_midi(pc), a1    ;
  279.         move.l        d0, iorec(a1)        ;
  280.         
  281.         rts
  282.  
  283. .set_midi:
  284.         lea            .map_midi(pc), a0    ;
  285.         lea            bcon_midi, a1        ;
  286.         move.l        (a1), (a0)+            ;
  287.         move.l        $20(a1), (a0)+        ;
  288.         move.l        $44(a1), (a0)+        ;
  289.         move.l        $60(a1), (a0)        ;
  290.         rts
  291.  
  292. .map_midi:    dcb.b    MAPTAB, 0
  293.  
  294. ;-------
  295. ; SetIorec
  296. ; ->    a0: Zeiger auf IOREC-Struktur
  297. ;        a1: Zeiger auf Speicherbereich
  298. ;        d0: Länge des Speicherblocks
  299. ; <-    nichts
  300. ;
  301. ; Die Funktion setzt die Adresse des Speicherbereichs in die
  302. ; IOREC-Struktur.
  303. ;
  304. SetIorec:
  305.         xdef        SetIorec            ; Funktion exportieren
  306.         
  307.         move.l        a0, dev                ; Adresse der Iorec-Struktur nach dev
  308.         move.l        a1, blk                ; Adresse des Speicherbereichs nach blk
  309.         move.w        d0, len                ; Länge des Speickerblocks
  310.         
  311.         pea            .sets(pc)            ; Im Supervisormodus ausführen
  312.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38)
  313.         trap        #14                    ; XBIOS-Trap
  314.         addq.l        #6, sp                ; Stack restaurieren
  315.         rts
  316.  
  317. .sets:
  318.         move.w        sr, d2                ; Status-Register in d1 retten
  319.         ori.w        #$700, sr            ; Interrupts sperren
  320.         
  321.         move.w        len(pc), d0            ; Länge holen
  322.         
  323.         movea.l        dev(pc), a0            ; Iorec Struktur holen
  324.         move.l        blk(pc), (a0)        ; neuen Block einsetzen
  325.         move.w        d0, 4(a0)            ; Länge einsetzen
  326.         clr.l        6(a0)                ; Schreib-/Leseposition 0 setzen
  327.         
  328.         lsr.w        #2, d0                ; untere Wassermarke
  329.         move.w        d0, 10(a0)            ; einsetzen
  330.         
  331.         move.w        d0, d1                ; obere Wassermarke
  332.         add.w        d1, d0                ;
  333.         add.w        d1, d0                ;
  334.         move.w        d0, 12(a0)            ; einsetzen
  335.         
  336.         move.w        d2, sr                ; Interrupts wieder freigeben
  337.         rts
  338.  
  339.  
  340. ;-------
  341. ; Funktionsname:    SendBlock
  342. ; ->    a0:    Pointer auf DEVICES-Struktur
  343. ;        a1:    Adresse des zu sendenden Blocks
  344. ;        d0:    Größe des Blocks
  345. ;        d1:    TRUE, wenn Carrier geprüft werden soll, sonst FALSE
  346. ; <-    TRUE wenn alles ok, sonst FALSE;
  347. ;
  348. ; Die Funktion sendet den Block über die serielle Schnittstelle.
  349. ;
  350. SendBlock:
  351.         xdef        SendBlock            ; Funktion exportieren
  352.         xdef        pause_2                ; 
  353.         
  354.         movem.l        a2-a6/d3-d7, -(sp)    ; Register retten
  355.         
  356.         move.l        a0, dev                ; Devices-Struktur,
  357.         move.l        a1, blk                ; Adresse des Blocks,
  358.         move.l        d0, len                ; zu sendende Länge und 
  359.         move.w        d1, tst                ; Carrier-Check retten
  360.         pea            .do_sendblock(pc)    ; Senderoutine auf den Stack
  361.         move.w        #$26, -(sp)            ; Opcode für Supexec (XBIOS 38 )
  362.         trap        #14                    ; XBIOS-Trap
  363.         addq.l        #6, sp                ; Stack restaurieren
  364.         
  365.         movem.l        (sp)+, a2-a6/d3-d7    ; Register restaurieren
  366.         
  367.         rts
  368.  
  369. .do_sendblock:
  370.         movea.l        blk(pc), a3            ; Adresse des Blocks nach a3
  371.         move.l        len(pc), d4            ; zu sendende Länge nach d4
  372.         move.w        tst(pc), d3            ; Carrier-Check Ja/Nein?
  373.         move.l        pause_2(pc), d5        ;
  374.         
  375.         ; Routinen holen:
  376.         movea.l        dev(pc), a0            ; Zeiger auf die DEVICES-Struktur
  377.         
  378.         move.w        func_num(a0), d0    ;
  379.         subq.w        #1, d0                ;
  380.         add.w        d0, d0                ;
  381.         add.w        d0, d0                ;
  382.         
  383.         lea            dcd_funcs(pc), a4    ;
  384.         move.l        (a4, d0.w), a4        ; DCD Funktionen
  385.         
  386.         movea.l        maptab(a0), a0        ; MAPTAB-Adresse
  387.         movea.l        bcostat(a0), a5        ; Adresse von Bcostat
  388.         movea.l        bconout(a0), a6        ; Adresse von Bconout
  389.         
  390. .b1:
  391.         tst.w        d3                    ; Carrier prüfen?
  392.         beq.b        .b2                    ; wenn nicht, dann weiter bei .b2
  393.         
  394.         jsr            (a4)                ; DCD testen
  395.         
  396.         tst.w        d0                    ; Carrier OK?
  397.         beq.b        .send_nok_ex        ; wenn kein Carrier, dann nix senden!
  398.         
  399. .b2:
  400.         subq.l        #1, d4                ; Counter erniedrigen
  401.         bmi.b        .send_ok_ex            ; wenn < 0, dann fertig!
  402.         
  403.         moveq        #0, d0                ; d0 löschen
  404.         move.b        (a3)+, d0            ; zu sendendes Byte nach d0
  405.         move.l        d0, -(sp)            ; zu sendendes Byte auf den Stack
  406.                                         ; + dummy für's Device, damit der
  407.                                         ; Offset stimmt.
  408. .wait:
  409.         jsr            (a5)                ; Einsprung in Bcostat
  410.         
  411.         tst.w        d0                    ; Kann Zeichen gesendet werden?
  412.         bne.b        .send_it            ; wenn ja, dann senden
  413.         
  414.         tst.l        d5                    ; Warteroutine gesetzt?
  415.         beq.b        .wait
  416.         
  417.         movea.l        d5, a0                ; Adresse holen und
  418.         jsr            (a0)                ; springen ...
  419.         bra.b        .wait
  420.         
  421. .send_it:        
  422.         ;*** Senden:
  423.         jsr            (a6)                ; Einsprung in Bconout
  424.         addq.l        #4, sp                ; Stack restaurieren
  425.         
  426.         bra.b        .b1                    ; weiter bei .b1 bis ende!
  427.         
  428. .send_ok_ex:
  429.         moveq        #1, d0
  430.         rts
  431.         
  432. .send_nok_ex:
  433.         clr.w        d0
  434.         rts
  435.  
  436. *****************************************************************************
  437.  
  438. dev:        dc.l    0
  439. blk:        dc.l    0
  440. len:        dc.l    0
  441. tst:        dc.w    0
  442.  
  443. pause_2:    dc.l    0
  444.  
  445.         .END
  446.